use nalgebra::Point2;

// 地图元素类型
#[derive(Debug, Clone, Copy)]
pub enum MapTile {
    Empty,        // 空白区域
    Wall,         // 不可摧毁障碍物
    Brick,        // 可摧毁障碍物
    SpawnPoint,   // 出生点
    ResourcePoint,// 资源点
}

// 地图结构
pub struct GameMap {
    pub(crate) width: usize,
    pub(crate) height: usize,
    tiles: Vec<Vec<MapTile>>,
    spawn_points: Vec<Point2<f32>>,     // 出生点列表
    resource_points: Vec<Point2<f32>>,  // 资源点列表
}

impl GameMap {
    pub fn new(width: usize, height: usize) -> Self {
        let mut tiles = vec![vec![MapTile::Empty; height]; width];
        
        // 初始化地图，这里可以添加随机生成逻辑
        GameMap {
            width,
            height,
            tiles,
            spawn_points: Vec::new(),
            resource_points: Vec::new(),
        }
    }
    
    // 获取指定位置的地图元素
    pub fn get_tile(&self, x: usize, y: usize) -> Option<MapTile> {
        if x < self.width && y < self.height {
            Some(self.tiles[x][y])
        } else {
            None
        }
    }
    
    // 设置指定位置的地图元素
    pub fn set_tile(&mut self, x: usize, y: usize, tile: MapTile) {
        if x < self.width && y < self.height {
            self.tiles[x][y] = tile;
            
            // 更新特殊点列表
            let point = Point2::new(x as f32, y as f32);
            match tile {
                MapTile::SpawnPoint => {
                    if !self.spawn_points.contains(&point) {
                        self.spawn_points.push(point);
                    }
                },
                MapTile::ResourcePoint => {
                    if !self.resource_points.contains(&point) {
                        self.resource_points.push(point);
                    }
                },
                _ => {}
            }
        }
    }
    
    // 检查位置是否可通过
    pub fn is_passable(&self, x: usize, y: usize) -> bool {
        match self.get_tile(x, y) {
            Some(MapTile::Empty) | Some(MapTile::ResourcePoint) | Some(MapTile::SpawnPoint) => true,
            _ => false,
        }
    }
    
    // 获取出生点
    pub fn get_spawn_points(&self) -> &Vec<Point2<f32>> {
        &self.spawn_points
    }
    
    // 获取资源点
    pub fn get_resource_points(&self) -> &Vec<Point2<f32>> {
        &self.resource_points
    }
    
    // 检查点是否在地图内
    pub fn is_in_bounds(&self, x: f32, y: f32) -> bool {
        x >= 0.0 && x < self.width as f32 && y >= 0.0 && y < self.height as f32
    }
    
    // 获取随机出生点
    pub fn get_random_spawn_point(&self) -> Option<Point2<f32>> {
        use rand::Rng;
        if !self.spawn_points.is_empty() {
            let mut rng = rand::thread_rng();
            let index = rng.gen_range(0..self.spawn_points.len());
            Some(self.spawn_points[index])
        } else {
            None
        }
    }
}